{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-03-21T09:06:58.423171Z",
     "start_time": "2025-03-21T09:06:55.902816Z"
    }
   },
   "source": [
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import random\n",
    "from tqdm import tqdm\n",
    "import collections\n",
    "import matplotlib.pyplot as plt"
   ],
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:11:24.221176Z",
     "start_time": "2025-03-21T09:11:24.205435Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class WorldEnv:\n",
    "    def __init__(self):\n",
    "        self.distance_threshold = 0.15\n",
    "        self.action_bound = 1\n",
    "\n",
    "    def reset(self):\n",
    "        # 生成一个目标状态，坐标范围是[3.5~4.5,3.5~4.5]\n",
    "        self.goal = np.array([4+random.uniform(-0.5,0.5),4+random.uniform(-0.5,0.5)])\n",
    "        self.state = np.array([0,0])  # 初始状态\n",
    "        self.count = 0\n",
    "        return np.hstack([self.state,self.goal])\n",
    "\n",
    "    def step(self,action):\n",
    "        action = np.clip(action,-self.action_bound,self.action_bound)\n",
    "        x = max(0,min(5,self.state[0] + action[0]))\n",
    "        y = max(0,min(5,self.state[1] + action[1]))\n",
    "        self.state = np.array([x,y])\n",
    "        self.count += 1\n",
    "\n",
    "        dis = np.sqrt(np.sum(np.square(self.state - self.goal)))\n",
    "        reward = -1.0 if dis > self.distance_threshold else 0\n",
    "        if dis <= self.distance_threshold or self.count == 50:\n",
    "            done = True\n",
    "        else:\n",
    "            done = False\n",
    "\n",
    "        return np.hstack((self.state,self.goal)), reward, done"
   ],
   "id": "1cc9d7c38ed89b9",
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:15:33.796361Z",
     "start_time": "2025-03-21T09:15:33.771734Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self,state_dim,hidden_dim,action_dim,action_bound):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim,hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim,hidden_dim)\n",
    "        self.fc3 = torch.nn.Linear(hidden_dim,action_dim)\n",
    "        self.action_bound = action_bound\n",
    "\n",
    "    def forward(self,x):\n",
    "        x = F.relu(self.fc2(F.relu(self.fc1(x))))\n",
    "        return torch.tanh(self.fc3(x)) * self.action_bound\n",
    "\n",
    "class QValueNet(torch.nn.Module):\n",
    "    def __init__(self,state_dim,hidden_dim,action_dim):\n",
    "        super(QValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim+action_dim,hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim,hidden_dim)\n",
    "        self.fc3 = torch.nn.Linear(hidden_dim,1)\n",
    "\n",
    "    def forward(self,x,a):\n",
    "        cat = torch.cat([x,a],dim=1)\n",
    "        x = F.relu(self.fc2(F.relu(self.fc1(cat))))\n",
    "        return self.fc3(x)"
   ],
   "id": "1e82326299869fbc",
   "outputs": [],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:25:43.959253Z",
     "start_time": "2025-03-21T09:25:43.932537Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class DDPG:\n",
    "    def __init__(self,state_dim,hidden_dim,action_dim,action_bound,\n",
    "                 actor_lr,critic_lr,sigma,tau,gamma,device):\n",
    "        self.action_dim = action_dim\n",
    "\n",
    "        self.actor = PolicyNet(state_dim,hidden_dim,action_dim,action_bound).to(device)\n",
    "        self.critic = QValueNet(state_dim,hidden_dim,action_dim).to(device)\n",
    "        self.target_actor = PolicyNet(state_dim,hidden_dim,action_dim,action_bound).to(device)\n",
    "        self.target_critic = QValueNet(state_dim,hidden_dim,action_dim).to(device)\n",
    "        self.target_actor.load_state_dict(self.actor.state_dict())\n",
    "        self.target_critic.load_state_dict(self.critic.state_dict())\n",
    "        self.actor_optimizer = torch.optim.Adam(self.actor.parameters(), lr=actor_lr)\n",
    "        self.critic_optimizer = torch.optim.Adam(self.critic.parameters(), lr=critic_lr)\n",
    "        self.gamma = gamma\n",
    "        self.sigma = sigma  # 高斯噪声的标准差，均值直接设为0\n",
    "        self.tau = tau\n",
    "        self.action_bound = action_bound\n",
    "        self.device = device\n",
    "\n",
    "    def take_action(self,state):\n",
    "        state = torch.tensor([state],dtype=torch.float).to(self.device)\n",
    "        action = self.actor(state).detach().cpu().numpy()[0]\n",
    "        # 给动作添加噪声，增加探索\n",
    "        action = action + self.sigma * np.random.randn(self.action_dim)\n",
    "        return action\n",
    "\n",
    "    def soft_update(self,net,target_net):\n",
    "        for param_target,param in zip(target_net.parameters(),net.parameters()):\n",
    "            param_target.data.copy_(param_target.data * (1.0 - self.tau) + param.data * self.tau)\n",
    "\n",
    "    def update(self,transition_dict):\n",
    "        states = torch.tensor(transition_dict['states'],dtype=torch.float).to(self.device)\n",
    "        actions = torch.tensor(transition_dict['actions'],dtype=torch.float).to(self.device)\n",
    "        rewards = torch.tensor(transition_dict['rewards'],dtype=torch.float).view(-1,1).to(self.device)\n",
    "        next_states = torch.tensor(transition_dict['next_states'],dtype=torch.float).to(self.device)\n",
    "        dones = torch.tensor(transition_dict['dones'],dtype=torch.float).view(-1,1).to(self.device)\n",
    "\n",
    "        next_q_values = self.target_critic(next_states,self.target_actor(next_states))\n",
    "        q_targets = rewards + self.gamma * next_q_values * (1 - dones)\n",
    "        critic_loss = torch.mean(F.mse_loss(self.critic(states,actions),q_targets))\n",
    "        self.critic_optimizer.zero_grad()\n",
    "        critic_loss.backward()\n",
    "        self.critic_optimizer.step()\n",
    "\n",
    "        # 策略网络为了使Q值最大化\n",
    "        actor_loss = -torch.mean(self.critic(states,self.actor(states)))\n",
    "        self.actor_optimizer.zero_grad()\n",
    "        actor_loss.backward()\n",
    "        self.actor_optimizer.step()\n",
    "\n",
    "        self.soft_update(self.critic,self.target_critic)\n",
    "        self.soft_update(self.actor,self.target_actor)"
   ],
   "id": "372d9c4da1fca064",
   "outputs": [],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:33:17.419515Z",
     "start_time": "2025-03-21T09:33:17.404252Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class Trajectory:\n",
    "    '''记录一条完整轨迹'''\n",
    "    def __init__(self,init_state):\n",
    "        self.states = [init_state]\n",
    "        self.actions = []\n",
    "        self.rewards = []\n",
    "        self.dones = []\n",
    "        self.length = 0\n",
    "\n",
    "    def store_step(self,action,state,reward,done):\n",
    "        self.actions.append(action)\n",
    "        self.states.append(state)\n",
    "        self.rewards.append(reward)\n",
    "        self.dones.append(done)\n",
    "        self.length += 1\n",
    "\n",
    "class ReplayBuffer_Trajectory:\n",
    "    def __init__(self,capacity):\n",
    "        self.buffer = collections.deque(maxlen=capacity)\n",
    "\n",
    "    def add_trajectory(self,trajectory):\n",
    "        self.buffer.append(trajectory)\n",
    "\n",
    "    def size(self):\n",
    "        return len(self.buffer)\n",
    "\n",
    "    def sample(self,batch_size,use_her,dis_threshold=0.15,her_ratio=0.8):\n",
    "        batch = dict(states=[],actions=[],next_states=[],rewards=[],dones=[])\n",
    "        for _ in range(batch_size):\n",
    "            traj = random.sample(self.buffer,1)[0]\n",
    "            step_state = np.random.randint(traj.length)\n",
    "            state = traj.states[step_state]\n",
    "            next_state = traj.states[step_state+1]\n",
    "            action = traj.actions[step_state]\n",
    "            reward = traj.rewards[step_state]\n",
    "            done = traj.dones[step_state]\n",
    "\n",
    "            if use_her and np.random.uniform() <= her_ratio:\n",
    "                step_goal = np.random.randint(step_state+1,traj.length+1)\n",
    "                goal = traj.states[step_goal][:2]  # 使用HER算法的future方案设置目标\n",
    "                dis = np.sqrt(np.sum(np.square(next_state[:2] - goal)))\n",
    "                reward = -1.0 if dis > dis_threshold else 0\n",
    "                done = False if dis > dis_threshold else True\n",
    "                state = np.hstack([state[:2],goal])\n",
    "                next_state = np.hstack([next_state[:2],goal])\n",
    "\n",
    "            batch['states'].append(state)\n",
    "            batch['actions'].append(action)\n",
    "            batch['next_states'].append(next_state)\n",
    "            batch['rewards'].append(reward)\n",
    "            batch['dones'].append(done)\n",
    "\n",
    "        batch['states'] = np.array(batch['states'])\n",
    "        batch['actions'] = np.array(batch['actions'])\n",
    "        batch['next_states'] = np.array(batch['next_states'])\n",
    "        return batch"
   ],
   "id": "1536c96c9dfd740d",
   "outputs": [],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:50:06.113320Z",
     "start_time": "2025-03-21T09:42:32.442701Z"
    }
   },
   "cell_type": "code",
   "source": [
    "actor_lr = 1e-3\n",
    "critic_lr = 1e-3\n",
    "hidden_dim = 128\n",
    "state_dim = 4\n",
    "action_dim = 2\n",
    "action_bound = 1\n",
    "sigma = 0.1\n",
    "tau = 0.005\n",
    "gamma = 0.98\n",
    "num_episodes = 2000\n",
    "n_train = 20\n",
    "batch_size = 256\n",
    "minimal_episodes = 200\n",
    "buffer_size = 10000\n",
    "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "random.seed(0)\n",
    "np.random.seed(0)\n",
    "torch.manual_seed(0)\n",
    "env = WorldEnv()\n",
    "replay_buffer = ReplayBuffer_Trajectory(buffer_size)\n",
    "agent = DDPG(state_dim,hidden_dim,action_dim, action_bound, actor_lr, critic_lr, sigma, tau, gamma, device)\n",
    "\n",
    "return_list = []\n",
    "for i in range(10):\n",
    "    with tqdm(total=int(num_episodes/10),desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes/10)):\n",
    "            episode_return = 0\n",
    "            state = env.reset()\n",
    "            traj = Trajectory(state)\n",
    "            done = False\n",
    "            while not done:\n",
    "                action = agent.take_action(state)\n",
    "                state, reward, done= env.step(action)\n",
    "                episode_return += reward\n",
    "                traj.store_step(action,state,reward,done)\n",
    "            replay_buffer.add_trajectory(traj)\n",
    "            return_list.append(episode_return)\n",
    "            if replay_buffer.size() > minimal_episodes:\n",
    "                for _ in range(n_train):\n",
    "                    transition_dict = replay_buffer.sample(batch_size,True)\n",
    "                    agent.update(transition_dict)\n",
    "            if (i_episode+1) % 10 ==0:\n",
    "                pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1),'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "            pbar.update(1)"
   ],
   "id": "7c0c1baf600b41e8",
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|██████████| 200/200 [00:02<00:00, 87.29it/s, episode=200, return=-50.000]\n",
      "Iteration 1: 100%|██████████| 200/200 [00:52<00:00,  3.82it/s, episode=400, return=-4.400]\n",
      "Iteration 2: 100%|██████████| 200/200 [00:51<00:00,  3.89it/s, episode=600, return=-4.100]\n",
      "Iteration 3: 100%|██████████| 200/200 [00:50<00:00,  3.93it/s, episode=800, return=-4.000]\n",
      "Iteration 4: 100%|██████████| 200/200 [00:47<00:00,  4.17it/s, episode=1000, return=-4.500]\n",
      "Iteration 5: 100%|██████████| 200/200 [00:48<00:00,  4.14it/s, episode=1200, return=-4.400]\n",
      "Iteration 6: 100%|██████████| 200/200 [00:49<00:00,  4.08it/s, episode=1400, return=-40.600]\n",
      "Iteration 7: 100%|██████████| 200/200 [00:49<00:00,  4.02it/s, episode=1600, return=-45.300]\n",
      "Iteration 8: 100%|██████████| 200/200 [00:50<00:00,  3.93it/s, episode=1800, return=-50.000]\n",
      "Iteration 9: 100%|██████████| 200/200 [00:50<00:00,  3.94it/s, episode=2000, return=-50.000]\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-03-21T09:50:06.349163Z",
     "start_time": "2025-03-21T09:50:06.142681Z"
    }
   },
   "cell_type": "code",
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list, return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "plt.title('DDPG with HER on {}'.format('GridWorld'))\n",
    "plt.show()"
   ],
   "id": "bb3af252140cbe0f",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": "",
   "id": "38996fae7446461"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
